package com.hugang.newfeature.streamapi;

import com.hugang.newfeature.methodrefernce.Employee;
import com.hugang.newfeature.methodrefernce.EmployeeData;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * 1、Stream关注的是对数据的运算，与cpu打交道
 *    集合关注的是数据的存储，与内存打交道
 * 2.
 * ①Stream 自己不会存储元素。
 * ②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
 * ③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
 *
 * 3.Stream 执行流程
 * ① Stream的实例化
 * ② 一系列的中间操作（过滤、映射、...)
 * ③ 终止操作
 *
 * 4.说明：
 * 4.1 一个中间操作链，对数据源的数据进行处理
 * 4.2 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用
 *
 *
 * 1、测试Stream的实例化
 *   1）方式一：通过集合
 *      default Stream<E> stream() : 返回一个顺序流
 *      default Stream<E> parallelStream() : 返回一个并行流
 *   2）方式二：通过数组
 *      Arrays类的 static <T> Stream<T> stream(T[] array)
 *   3）方式三：通过Stream的of()
 *   4）方式四：创建无限流(了解)
 *
 * @author hg
 * @date 2020/6/26 17:44
 */
public class StreamAPITest {

    @Test
    public void test1(){
        //方式一：通过集合
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<Employee> stream = employees.stream();

        Stream<Employee> employeeStream = employees.parallelStream();

        //方式二：通过数组
        IntStream stream1 = Arrays.stream(new int[]{1, 2, 3, 4, 5, 6});
        Stream<Employee> stream2 = Arrays.stream(new Employee[]{new Employee(), new Employee()});

        //方式三：Stream.of()
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);

        //方式四：创建无限流

        //      迭代
//      public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //遍历前10个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
        List<Integer> collect = Stream.iterate(0, t -> t + 2).limit(10).collect(Collectors.toList());
        System.out.println(collect);


//      生成
//      public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }


}
